home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 33 / Amiga Format AFCD33 (Issue 117, Dec 1998).iso / -seriously_amiga- / archivers / unrar / src-orig / block.c next >
Text File  |  1998-09-07  |  7KB  |  231 lines
  1. #define GetHeaderByte(N) Header[N]
  2.  
  3. #define GetHeaderWord(N) (Header[N]+((UWORD)Header[N+1]<<8))
  4.  
  5. #define GetHeaderDword(N) (Header[N]+((UWORD)Header[N+1]<<8)+\
  6.                           ((UDWORD)Header[N+2]<<16)+\
  7.                           ((UDWORD)Header[N+3]<<24))
  8.  
  9.  
  10. int IsProcessFile(int ComparePath)
  11. {
  12.   int Wildcards;
  13.   char PathArg[NM],NameArg[NM];
  14.   char PathArc[NM],NameArc[NM];
  15.   for (NextArgName(ARG_RESET);NextArgName(ARG_NEXT);)
  16.   {
  17.     Wildcards=SplitPath(ArgName,PathArg,NameArg,1);
  18.     SplitPath(ArcFileName,PathArc,NameArc,1);
  19.     if (!ExclCheck(ArcFileName) && CmpName(NameArg,NameArc,0))
  20.       if ((ComparePath==NOT_COMPARE_PATH && *PathArg==0) ||
  21.           (stricomp(PathArg,PathArc)==0 ||
  22.           Wildcards && strnicomp (PathArg,PathArc,strlen(PathArg))==0 ))
  23.        return(1);
  24.   }
  25.   return(0);
  26. }
  27.  
  28.  
  29. int ReadBlock(int BlockType)
  30. {
  31.   struct NewFileHeader SaveFileHead;
  32.   int Size,ReadSubBlock=0;
  33.   static int LastBlock;
  34.   BrokenFileHeader=0;
  35.   memcpy(&SaveFileHead,&NewLhd,sizeof(SaveFileHead));
  36.   if (BlockType & READSUBBLOCK)
  37.     ReadSubBlock=1;
  38.   BlockType &= 0xff;
  39.   if (ArcFormat==OLD)
  40.   {
  41.     memset(&OldLhd,0,sizeof(OldLhd));
  42.     CurBlockPos=ftell(ArcPtr);
  43.     Size=ReadHeader(FILE_HEAD);
  44.     if (Size != 0)
  45.       if (OldLhd.Method > SIZEOF_SHORTBLOCKHEAD || OldLhd.NameSize==0 || OldLhd.NameSize > 80 ||
  46.           OldLhd.UnpVer==0 || OldLhd.UnpVer > 20 || OldLhd.HeadSize <= 21 ||
  47.           OldLhd.Flags<8 && OldLhd.HeadSize!=21+OldLhd.NameSize)
  48.         return(0);
  49.     NewLhd.HeadType=FILE_HEAD;
  50.     NewLhd.HeadSize=OldLhd.HeadSize;
  51.     NewLhd.Flags=OldLhd.Flags|LONG_BLOCK;
  52.     NewLhd.PackSize=OldLhd.PackSize;
  53.     NewLhd.UnpSize=OldLhd.UnpSize;
  54.     NewLhd.FileTime=OldLhd.FileTime;
  55.     NewLhd.UnpVer=(OldLhd.UnpVer==2) ? 13 : 10;
  56.     NewLhd.Method=OldLhd.Method+0x30;
  57.     NewLhd.NameSize=OldLhd.NameSize;
  58.     NewLhd.FileAttr=OldLhd.FileAttr;
  59.     NewLhd.FileCRC=OldLhd.FileCRC;
  60.     if (Size!=0)
  61.       NextBlockPos=CurBlockPos+OldLhd.HeadSize+OldLhd.PackSize;
  62.   }
  63.   else
  64.   {
  65.     while (1)
  66.     {
  67.       CurBlockPos=ftell(ArcPtr);
  68.       Size=ReadHeader(FILE_HEAD);
  69.       if (Size!=0)
  70.       {
  71.         if (NewLhd.HeadSize<SIZEOF_SHORTBLOCKHEAD)
  72.           return(0);
  73.         NextBlockPos=CurBlockPos+NewLhd.HeadSize;
  74.         if (NewLhd.Flags & LONG_BLOCK)
  75.           NextBlockPos+=NewLhd.PackSize;
  76.         if (NextBlockPos<=CurBlockPos)
  77.           return(0);
  78.       }
  79.       else
  80.         if (filelen(ArcPtr) < NextBlockPos)
  81.           mprintf(MUnexpEOF);
  82.       if (Size > 0 && BlockType!=SUB_HEAD)
  83.         LastBlock=BlockType;
  84.       if (Size==0 || BlockType==ALL_HEAD || NewLhd.HeadType==BlockType ||
  85.           (NewLhd.HeadType==SUB_HEAD && ReadSubBlock && LastBlock==BlockType))
  86.         break;
  87.       tseek(ArcPtr,NextBlockPos,SEEK_SET);
  88.     }
  89.   }
  90.  
  91.   BlockHead.HeadCRC=NewLhd.HeadCRC;
  92.   BlockHead.HeadType=NewLhd.HeadType;
  93.   BlockHead.Flags=NewLhd.Flags;
  94.   BlockHead.HeadSize=NewLhd.HeadSize;
  95.   BlockHead.DataSize=NewLhd.PackSize;
  96.  
  97.   if (BlockType!=NewLhd.HeadType)
  98.     BlockType=ALL_HEAD;
  99.   switch(BlockType)
  100.   {
  101.     case FILE_HEAD:
  102.       if (Size>0)
  103.       {
  104.         NewLhd.NameSize=Min(NewLhd.NameSize,sizeof(ArcFileName)-1);
  105.         tread(ArcPtr,ArcFileName,NewLhd.NameSize);
  106.         ArcFileName[NewLhd.NameSize]=0;
  107.         if (ArcFormat==NEW && NewLhd.HeadCRC!=(UWORD)~CRC(HeaderCRC,&ArcFileName[0],NewLhd.NameSize,CRC32))
  108.         {
  109.           BrokenFileHeader=1;
  110.           mprintf(MBrokFileHead,ArcFileName);
  111.         }
  112.         if (Opt.ConvertNames==NAMES_UPPERCASE)
  113.           strupper(ArcFileName);
  114.         if (Opt.ConvertNames==NAMES_LOWERCASE)
  115.           strlower(ArcFileName);
  116.         Size+=NewLhd.NameSize;
  117.         ConvertUnknownHeader();
  118.       }
  119.       break;
  120.     default:
  121.       memcpy(&NewLhd,&SaveFileHead,sizeof(NewLhd));
  122.       tseek(ArcPtr,CurBlockPos,SEEK_SET);
  123.       break;
  124.   }
  125.   return(Size);
  126. }
  127.  
  128.  
  129. int ReadHeader(int BlockType)
  130. {
  131.   int Size;
  132.   unsigned char Header[64];
  133.   switch(BlockType)
  134.   {
  135.     case MAIN_HEAD:
  136.       if (ArcFormat==OLD)
  137.       {
  138.         Size=tread(ArcPtr,Header,SIZEOF_OLDMHD);
  139.         memcpy(OldMhd.Mark,Header,4);
  140.         OldMhd.HeadSize=GetHeaderWord(4);
  141.         OldMhd.Flags=GetHeaderByte(6);
  142.       }
  143.       else
  144.       {
  145.         Size=tread(ArcPtr,Header,SIZEOF_NEWMHD);
  146.         NewMhd.HeadCRC=GetHeaderWord(0);
  147.         NewMhd.HeadType=GetHeaderByte(2);
  148.         NewMhd.Flags=GetHeaderWord(3);
  149.         NewMhd.HeadSize=GetHeaderWord(5);
  150.         NewMhd.Reserved=GetHeaderWord(7);
  151.         NewMhd.Reserved1=GetHeaderDword(9);
  152.         HeaderCRC=CRC(0xFFFFFFFFL,&Header[2],SIZEOF_NEWMHD-2,CRC32);
  153.       }
  154.       break;
  155.     case FILE_HEAD:
  156.       if (ArcFormat==OLD)
  157.       {
  158.         Size=tread(ArcPtr,Header,SIZEOF_OLDLHD);
  159.         OldLhd.PackSize=GetHeaderDword(0);
  160.         OldLhd.UnpSize=GetHeaderDword(4);
  161.         OldLhd.FileCRC=GetHeaderWord(8);
  162.         OldLhd.HeadSize=GetHeaderWord(10);
  163.         OldLhd.FileTime=GetHeaderDword(12);
  164.         OldLhd.FileAttr=GetHeaderByte(16);
  165.         OldLhd.Flags=GetHeaderByte(17);
  166.         OldLhd.UnpVer=GetHeaderByte(18);
  167.         OldLhd.NameSize=GetHeaderByte(19);
  168.         OldLhd.Method=GetHeaderByte(20);
  169.       }
  170.       else
  171.       {
  172.         Size=tread(ArcPtr,Header,SIZEOF_NEWLHD);
  173.         NewLhd.HeadCRC=GetHeaderWord(0);
  174.         NewLhd.HeadType=GetHeaderByte(2);
  175.         NewLhd.Flags=GetHeaderWord(3);
  176.         NewLhd.HeadSize=GetHeaderWord(5);
  177.         NewLhd.PackSize=GetHeaderDword(7);
  178.         NewLhd.UnpSize=GetHeaderDword(11);
  179.         NewLhd.HostOS=GetHeaderByte(15);
  180.         NewLhd.FileCRC=GetHeaderDword(16);
  181.         NewLhd.FileTime=GetHeaderDword(20);
  182.         NewLhd.UnpVer=GetHeaderByte(24);
  183.         NewLhd.Method=GetHeaderByte(25);
  184.         NewLhd.NameSize=GetHeaderWord(26);
  185.         NewLhd.FileAttr=GetHeaderDword(28);
  186.         HeaderCRC=CRC(0xFFFFFFFFL,&Header[2],SIZEOF_NEWLHD-2,CRC32);
  187.       }
  188.       break;
  189.     case COMM_HEAD:
  190.       Size=tread(ArcPtr,Header,SIZEOF_COMMHEAD);
  191.       CommHead.HeadCRC=GetHeaderWord(0);
  192.       CommHead.HeadType=GetHeaderByte(2);
  193.       CommHead.Flags=GetHeaderWord(3);
  194.       CommHead.HeadSize=GetHeaderWord(5);
  195.       CommHead.UnpSize=GetHeaderWord(7);
  196.       CommHead.UnpVer=GetHeaderByte(9);
  197.       CommHead.Method=GetHeaderByte(10);
  198.       CommHead.CommCRC=GetHeaderWord(11);
  199.       HeaderCRC=CRC(0xFFFFFFFFL,&Header[2],SIZEOF_COMMHEAD-2,CRC32);
  200.       break;
  201.     case PROTECT_HEAD:
  202.       Size=tread(ArcPtr,Header,SIZEOF_PROTECTHEAD);
  203.       ProtectHead.HeadCRC=GetHeaderWord(0);
  204.       ProtectHead.HeadType=GetHeaderByte(2);
  205.       ProtectHead.Flags=GetHeaderWord(3);
  206.       ProtectHead.HeadSize=GetHeaderWord(5);
  207.       ProtectHead.DataSize=GetHeaderDword(7);
  208.       ProtectHead.Version=GetHeaderByte(11);
  209.       ProtectHead.RecSectors=GetHeaderWord(12);
  210.       ProtectHead.TotalBlocks=GetHeaderDword(14);
  211.       memcpy(ProtectHead.Mark,&Header[18],8);
  212.       HeaderCRC=CRC(0xFFFFFFFFL,&Header[2],SIZEOF_PROTECTHEAD-2,CRC32);
  213.       break;
  214.     case ALL_HEAD:
  215.       Size=tread(ArcPtr,Header,SIZEOF_SHORTBLOCKHEAD);
  216.       BlockHead.HeadCRC=GetHeaderWord(0);
  217.       BlockHead.HeadType=GetHeaderByte(2);
  218.       BlockHead.Flags=GetHeaderWord(3);
  219.       BlockHead.HeadSize=GetHeaderWord(5);
  220.       if (BlockHead.Flags & LONG_BLOCK)
  221.       {
  222.         Size+=tread(ArcPtr,&Header[7],4);
  223.         BlockHead.DataSize=GetHeaderDword(7);
  224.       }
  225.       break;
  226.   }
  227.   return(Size);
  228. }
  229.  
  230.  
  231.